#include "judge.h"

int outputOne[1000];//符合条件1的数组
int outputTwo[1000];//符合条件2的数组
int outputThree[1000];//符合条件3的数组



int digit(int input)//判断输入数据a是多少位
{
    int count = 0;
    if(input != 0)//如果输入的是0，单独判断
    {
        while(input != 0)
        {
            input/=10;
            count++;
        }
    }
    else
        count = 1;

    return count;
}



int judgeOne(int firstInput, int secondInput)//判读在0-a之间，所有含有b的数字
{
    int count;//正在判断的数的有多少位
    int now;//现在正在判断的数
    int param;//判断now中是否含有b的循环参数
    int power;//用以表示10的几次放
    int judge;//判断每一位和b是否相同的参数
    int outputOneInside = 0;//上述数组内部参数
    int testNumber;//在循环中替代now作为被减数

    printf("将0-a中，所有含有数b的数打印出来\n");

    if(firstInput != 0)
    {
        for(now=0; now<firstInput; now++)
        {
            testNumber = now;
            count = digit(now);//正在判断的数now有count位
            for(param=count-1; param>=0; param--)//以10的幂次作为循环条件
            {
                power = pow(10, param);//power是10的几次方
                judge = testNumber / power;
                if(judge == secondInput)
                {
                    outputOne[outputOneInside] = now;
                    printf("%d  ", outputOne[outputOneInside]);
                    outputOneInside++;
                }
                testNumber = testNumber - power*judge;//每一位判断完了之后，减去这一位数字
            }
        }
    }
    else
        printf("a的值不可为0\n");

    return outputOneInside;
}

int judgeTwo(int firstInput, int secondInput)//判断在0-a之间，所以能被b整除的数
{
    int left;//余数
    int now;//现在正在判断的数
    int outputTwoInside = 0;//上述数组内部参数

    printf("\n\n将0-a中，能被b整除的数打印出来\n");


    for(now=0; now<firstInput; now++)
    {
        left = now % secondInput;
        if(left == 0)
        {
            outputTwo[outputTwoInside] = now;
            printf("%d  ", outputTwo[outputTwoInside]);
            outputTwoInside++;
        }
    }

    return outputTwoInside;
}


void judgeThree(int firstInput, int outputOneInside, int outputTwoInside)//将0-a中，除去条件一和条件二以外所有的数，打印出来
{
    int outputThreeInside = 0;//上述数组内部参数
    int now;//正在判断的数
    int loopParamOne;//判断是否和条件一的数据相同的循环参数
    int loopParamTwo;//判断是否和条件二的数据相同的循环参数
    int supportArray[1000];//帮助删除符合条件一和条件二的值的辅助数组
    int supportArrayInside = 0;//帮助删除符合条件一和条件二的值的辅助数组的参数

    printf("\n\n");


    for(now=0; now<firstInput; now++)//建立一个从0到a的完整数组
    {
        outputThree[now] = now;
    }


    for(now=0; now<firstInput; now++)//从outputThree数组中除去符合条件一的数字，形成新的数组supportArray
    {
        for(loopParamOne=0; loopParamOne<outputOneInside; loopParamOne++)
        {
            if(outputThree[now] == outputOne[loopParamOne] )
            {
                break;
            }
            else
            {
                if(loopParamOne != outputOneInside-1)
                {
                    continue;
                }
                else
                {
                    supportArray[supportArrayInside] = outputThree[now];
                    //printf("%d  ", supportArray[supportArrayInside]);
                    supportArrayInside++;
                }
            }
        }
    }

    printf("将0-a中，除去条件一和条件二以外所有的数，打印出来");

    for(now=0; now<supportArrayInside; now++)//从supportArray数组中除去符合条件一的数字，形成新的数组outputThree
    {
        for(loopParamTwo=0; loopParamTwo<outputTwoInside; loopParamTwo++)
        {
            if(supportArray[now] == outputTwo[loopParamTwo] )
            {
                break;
            }
            else
            {
                if(loopParamTwo != outputTwoInside-1)
                {
                    continue;
                }
                else
                {
                    outputThree[outputThreeInside] = supportArray[now];
                    printf("%d  ", outputThree[outputThreeInside]);
                    outputThreeInside++;
                }
            }
        }
    }

    return;
}



